﻿using System;
using System.Collections.Generic;
// Pour la connexion à SQLServer
// Pour l'utilisation de NHibernate
using NHibernate;
using NHibernate.Criterion;
using Annuaire;
using System.Reflection;
using log4net;
using log4net.Config;
using log4net.Repository.Hierarchy;
using log4net.Appender;


[assembly: log4net.Config.XmlConfigurator(Watch = true)]
namespace annuairedotnet
{
    /// <summary>
    /// Description résumée de ContactDao
    /// </summary>
    
    public class ContactDao
    {
        private static readonly ILog log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);

        public ContactDao() {
            log4net.Config.XmlConfigurator.Configure();
        }

        public static void saveOrUpdate(Contact contact)
        {
            ISession session = NHibernateUtils.getSession();
            ITransaction tx = null;

            try
            {
                tx = session.BeginTransaction();

                session.SaveOrUpdate(contact);

                tx.Commit();
            }
            catch (HibernateException he)
            {
                if (tx != null)
                {
                    try
                    {
                        tx.Rollback();
                    }
                    catch (Exception e)
                    {
                        log.Error("[saveOrUpdate(Contact contact)] - Erreur lors de la sauvegarde du contact : " + e);
                    }
                }
            }
            finally
            {
                NHibernateUtils.closeSession();
                log.Info("[saveOrUpdate(Contact contact)] - Sauvegarde d'un contact");
            }
        }

        public static void removeContact(Contact contact)
        {
            ISession session = NHibernateUtils.getSession();
            ITransaction tx = null;

            try
            {
                tx = session.BeginTransaction();

                session.Delete(contact);

                tx.Commit();
            }
            catch (HibernateException he)
            {
                if (tx != null)
                {
                    try
                    {
                        tx.Rollback();
                    }
                    catch (Exception e)
                    {
                        log.Error("[removeContact(Contact contact)] - Erreur lors de la suppression du contact : " + e);
                    }
                }
            }
            finally
            {
                NHibernateUtils.closeSession();
                log.Info("[removeContact(Contact contact)] - Suppression d'un contact");
            }
        }

        public static Contact getById(int id)
        {
            ISession session = NHibernateUtils.getSession();
            ITransaction tx = null;
            Contact contact = null;

            try
            {
                tx = session.BeginTransaction();

                contact = (Contact)session.Load(typeof(Contact), id);

                tx.Commit();
            }
            catch (HibernateException he)
            {
                if (tx != null)
                {
                    try
                    {
                        tx.Rollback();
                    }
                    catch (Exception e)
                    {
                        log.Error("[getById(int id)] - Erreur lors du chargement du contact en fonction de son Id : " + e);
                    }
                }
            }
            finally
            {
                NHibernateUtils.closeSession();
                log.Info("[getById(int id)] - Chargement d'un contact en fonction de son Id");

            }

            return contact;
        }

        public static IList<Contact> getAll()
        {
            ISession session = NHibernateUtils.getSession();
            ITransaction tx = null;
            IList<Contact> contacts = new List<Contact>();

            try
            {
                tx = session.BeginTransaction();

                contacts = session.CreateQuery("FROM Contact").List<Contact>();

                tx.Commit();
            }
            catch (HibernateException he)
            {
                if (tx != null)
                {
                    try
                    {
                        tx.Rollback();
                    }
                    catch (Exception e)
                    {
                        log.Error("[getAll()] - Erreur lors du chargement de tous contact : " + e);
                    }
                }
            }
            finally
            {
                NHibernateUtils.closeSession();
                log.Info("[getAll()] - Chargement de tous les contacts");
            }

            return contacts;
        }

        public static IList<Contact> getByCritere(ContactCritere critere)
        {
            ISession session = NHibernateUtils.getSession();
            ITransaction tx = null;
            IList<Contact> contacts = null;

            try
            {
                tx = session.BeginTransaction();

                ICriteria crit = session.CreateCriteria(typeof(Contact));
                if (critere.Nom != string.Empty)
                    crit.Add(Expression.Like("Nom", critere.Nom + "%"));

                if (critere.Prenom != string.Empty)
                    crit.Add(Expression.Like("Prenom", critere.Prenom + "%"));

                if (critere.Societe != string.Empty)
                    crit.CreateCriteria("DonneesPro").Add(Expression.Like("Societe", critere.Societe + "%"));

                if (critere.VillePerso != string.Empty)
                    crit.CreateCriteria("DonneesPerso").Add(Expression.Like("VillePerso", critere.VillePerso + "%"));

                if (critere.VillePro != string.Empty)
                    crit.CreateCriteria("DonneesPro").Add(Expression.Like("VillePro", critere.VillePro + "%"));

                contacts = crit.List<Contact>();

                tx.Commit();
            }
            catch (HibernateException he)
            {
                if (tx != null)
                {
                    try
                    {
                        tx.Rollback();
                    }
                    catch (Exception e)
                    {
                        log.Error("[getByCritere(ContactCritere critere)] - Erreur lors du chargement de contacts en fonction des critères : " + e);
                    }
                }
            }
            finally
            {
                NHibernateUtils.closeSession();
                log.Info("[Chargement de contacts en fonction des critères]");        
            }

            return contacts;
        }
    }
}
